diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
index dab2bc4a5a..af0cc4aab1 100644
--- a/lib/matplotlib/figure.py
+++ b/lib/matplotlib/figure.py
@@ -1017,7 +1017,7 @@ default: %(va)s
     #    " legend(" -> " figlegend(" for the signatures
     #    "fig.legend(" -> "plt.figlegend" for the code examples
     #    "ax.plot" -> "plt.plot" for consistency in using pyplot when able
-    @_docstring.dedent_interpd
+    @_docstring.interpd
     def legend(self, *args, **kwargs):
         """
         Place a legend on the figure.
@@ -1312,236 +1312,6 @@ default: %(va)s
         cax.figure.stale = True
         return cb
 
-    def subplots_adjust(self, left=None, bottom=None, right=None, top=None,
-                        wspace=None, hspace=None):
-        """
-        Adjust the subplot layout parameters.
-
-        Unset parameters are left unmodified; initial values are given by
-        :rc:`figure.subplot.[name]`.
-
-        Parameters
-        ----------
-        left : float, optional
-            The position of the left edge of the subplots,
-            as a fraction of the figure width.
-        right : float, optional
-            The position of the right edge of the subplots,
-            as a fraction of the figure width.
-        bottom : float, optional
-            The position of the bottom edge of the subplots,
-            as a fraction of the figure height.
-        top : float, optional
-            The position of the top edge of the subplots,
-            as a fraction of the figure height.
-        wspace : float, optional
-            The width of the padding between subplots,
-            as a fraction of the average Axes width.
-        hspace : float, optional
-            The height of the padding between subplots,
-            as a fraction of the average Axes height.
-        """
-        if (self.get_layout_engine() is not None and
-                not self.get_layout_engine().adjust_compatible):
-            _api.warn_external(
-                "This figure was using a layout engine that is "
-                "incompatible with subplots_adjust and/or tight_layout; "
-                "not calling subplots_adjust.")
-            return
-        self.subplotpars.update(left, bottom, right, top, wspace, hspace)
-        for ax in self.axes:
-            if ax.get_subplotspec() is not None:
-                ax._set_position(ax.get_subplotspec().get_position(self))
-        self.stale = True
-
-    def align_xlabels(self, axs=None):
-        """
-        Align the xlabels of subplots in the same subplot column if label
-        alignment is being done automatically (i.e. the label position is
-        not manually set).
-
-        Alignment persists for draw events after this is called.
-
-        If a label is on the bottom, it is aligned with labels on Axes that
-        also have their label on the bottom and that have the same
-        bottom-most subplot row.  If the label is on the top,
-        it is aligned with labels on Axes with the same top-most row.
-
-        Parameters
-        ----------
-        axs : list of `~matplotlib.axes.Axes`
-            Optional list of (or `~numpy.ndarray`) `~matplotlib.axes.Axes`
-            to align the xlabels.
-            Default is to align all Axes on the figure.
-
-        See Also
-        --------
-        matplotlib.figure.Figure.align_ylabels
-        matplotlib.figure.Figure.align_labels
-
-        Notes
-        -----
-        This assumes that ``axs`` are from the same `.GridSpec`, so that
-        their `.SubplotSpec` positions correspond to figure positions.
-
-        Examples
-        --------
-        Example with rotated xtick labels::
-
-            fig, axs = plt.subplots(1, 2)
-            for tick in axs[0].get_xticklabels():
-                tick.set_rotation(55)
-            axs[0].set_xlabel('XLabel 0')
-            axs[1].set_xlabel('XLabel 1')
-            fig.align_xlabels()
-        """
-        if axs is None:
-            axs = self.axes
-        axs = [ax for ax in np.ravel(axs) if ax.get_subplotspec() is not None]
-        for ax in axs:
-            _log.debug(' Working on: %s', ax.get_xlabel())
-            rowspan = ax.get_subplotspec().rowspan
-            pos = ax.xaxis.get_label_position()  # top or bottom
-            # Search through other axes for label positions that are same as
-            # this one and that share the appropriate row number.
-            # Add to a grouper associated with each axes of siblings.
-            # This list is inspected in `axis.draw` by
-            # `axis._update_label_position`.
-            for axc in axs:
-                if axc.xaxis.get_label_position() == pos:
-                    rowspanc = axc.get_subplotspec().rowspan
-                    if (pos == 'top' and rowspan.start == rowspanc.start or
-                            pos == 'bottom' and rowspan.stop == rowspanc.stop):
-                        # grouper for groups of xlabels to align
-                        self._align_label_groups['x'].join(ax, axc)
-
-    def align_ylabels(self, axs=None):
-        """
-        Align the ylabels of subplots in the same subplot column if label
-        alignment is being done automatically (i.e. the label position is
-        not manually set).
-
-        Alignment persists for draw events after this is called.
-
-        If a label is on the left, it is aligned with labels on Axes that
-        also have their label on the left and that have the same
-        left-most subplot column.  If the label is on the right,
-        it is aligned with labels on Axes with the same right-most column.
-
-        Parameters
-        ----------
-        axs : list of `~matplotlib.axes.Axes`
-            Optional list (or `~numpy.ndarray`) of `~matplotlib.axes.Axes`
-            to align the ylabels.
-            Default is to align all Axes on the figure.
-
-        See Also
-        --------
-        matplotlib.figure.Figure.align_xlabels
-        matplotlib.figure.Figure.align_labels
-
-        Notes
-        -----
-        This assumes that ``axs`` are from the same `.GridSpec`, so that
-        their `.SubplotSpec` positions correspond to figure positions.
-
-        Examples
-        --------
-        Example with large yticks labels::
-
-            fig, axs = plt.subplots(2, 1)
-            axs[0].plot(np.arange(0, 1000, 50))
-            axs[0].set_ylabel('YLabel 0')
-            axs[1].set_ylabel('YLabel 1')
-            fig.align_ylabels()
-        """
-        if axs is None:
-            axs = self.axes
-        axs = [ax for ax in np.ravel(axs) if ax.get_subplotspec() is not None]
-        for ax in axs:
-            _log.debug(' Working on: %s', ax.get_ylabel())
-            colspan = ax.get_subplotspec().colspan
-            pos = ax.yaxis.get_label_position()  # left or right
-            # Search through other axes for label positions that are same as
-            # this one and that share the appropriate column number.
-            # Add to a list associated with each axes of siblings.
-            # This list is inspected in `axis.draw` by
-            # `axis._update_label_position`.
-            for axc in axs:
-                if axc.yaxis.get_label_position() == pos:
-                    colspanc = axc.get_subplotspec().colspan
-                    if (pos == 'left' and colspan.start == colspanc.start or
-                            pos == 'right' and colspan.stop == colspanc.stop):
-                        # grouper for groups of ylabels to align
-                        self._align_label_groups['y'].join(ax, axc)
-
-    def align_labels(self, axs=None):
-        """
-        Align the xlabels and ylabels of subplots with the same subplots
-        row or column (respectively) if label alignment is being
-        done automatically (i.e. the label position is not manually set).
-
-        Alignment persists for draw events after this is called.
-
-        Parameters
-        ----------
-        axs : list of `~matplotlib.axes.Axes`
-            Optional list (or `~numpy.ndarray`) of `~matplotlib.axes.Axes`
-            to align the labels.
-            Default is to align all Axes on the figure.
-
-        See Also
-        --------
-        matplotlib.figure.Figure.align_xlabels
-
-        matplotlib.figure.Figure.align_ylabels
-        """
-        self.align_xlabels(axs=axs)
-        self.align_ylabels(axs=axs)
-
-    def add_gridspec(self, nrows=1, ncols=1, **kwargs):
-        """
-        Return a `.GridSpec` that has this figure as a parent.  This allows
-        complex layout of Axes in the figure.
-
-        Parameters
-        ----------
-        nrows : int, default: 1
-            Number of rows in grid.
-
-        ncols : int, default: 1
-            Number of columns in grid.
-
-        Returns
-        -------
-        `.GridSpec`
-
-        Other Parameters
-        ----------------
-        **kwargs
-            Keyword arguments are passed to `.GridSpec`.
-
-        See Also
-        --------
-        matplotlib.pyplot.subplots
-
-        Examples
-        --------
-        Adding a subplot that spans two rows::
-
-            fig = plt.figure()
-            gs = fig.add_gridspec(2, 2)
-            ax1 = fig.add_subplot(gs[0, 0])
-            ax2 = fig.add_subplot(gs[1, 0])
-            # spans two rows:
-            ax3 = fig.add_subplot(gs[:, 1])
-
-        """
-
-        _ = kwargs.pop('figure', None)  # pop in case user has added this...
-        gs = GridSpec(nrows=nrows, ncols=ncols, figure=self, **kwargs)
-        return gs
-
     def subfigures(self, nrows=1, ncols=1, squeeze=True,
                    wspace=None, hspace=None,
                    width_ratios=None, height_ratios=None,
@@ -1574,13 +1344,30 @@ default: %(va)s
         width_ratios : array-like of length *ncols*, optional
             Defines the relative widths of the columns. Each column gets a
             relative width of ``width_ratios[i] / sum(width_ratios)``.
-            If not given, all columns will have the same width.
+            If not given, all columns will have the same width.  Equivalent
+            to ``gridspec_kw={'width_ratios': [...]}``. In the case of nested
+            layouts, this argument applies only to the outer layout.
 
         height_ratios : array-like of length *nrows*, optional
             Defines the relative heights of the rows. Each row gets a
             relative height of ``height_ratios[i] / sum(height_ratios)``.
-            If not given, all rows will have the same height.
+            If not given, all rows will have the same height. Equivalent
+            to ``gridspec_kw={'height_ratios': [...]}``. In the case of nested
+            layouts, this argument applies only to the outer layout.
         """
+        gridspec_kw = dict(gridspec_kw or {})
+        if height_ratios is not None:
+            if 'height_ratios' in gridspec_kw:
+                raise ValueError("'height_ratios' must not be defined both as "
+                                 "parameter and as key in 'gridspec_kw'")
+            gridspec_kw['height_ratios'] = height_ratios
+        if width_ratios is not None:
+            if 'width_ratios' in gridspec_kw:
+                raise ValueError("'width_ratios' must not be defined both as "
+                                 "parameter and as key in 'gridspec_kw'")
+            gridspec_kw['width_ratios'] = width_ratios
+
+        # create a GridSpec instance
         gs = GridSpec(nrows=nrows, ncols=ncols, figure=self,
                       wspace=wspace, hspace=hspace,
                       width_ratios=width_ratios,
@@ -1738,7 +1525,7 @@ default: %(va)s
             Renderer that will be used to draw the figures (i.e.
             ``fig.canvas.get_renderer()``)
 
-        bbox_extra_artists : list of `.Artist` or ``None``
+        bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional
             List of artists to include in the tight bounding box.  If
             ``None`` (default), then all artist children of each Axes are
             included in the tight bounding box.
@@ -2572,165 +2359,6 @@ None}, default: None
         if not self.canvas.widgetlock.locked():
             super().pick(mouseevent)
 
-    def _check_layout_engines_compat(self, old, new):
-        """
-        Helper for set_layout engine
-
-        If the figure has used the old engine and added a colorbar then the
-        value of colorbar_gridspec must be the same on the new engine.
-        """
-        if old is None or new is None:
-            return True
-        if old.colorbar_gridspec == new.colorbar_gridspec:
-            return True
-        # colorbar layout different, so check if any colorbars are on the
-        # figure...
-        for ax in self.axes:
-            if hasattr(ax, '_colorbar'):
-                # colorbars list themselves as a colorbar.
-                return False
-        return True
-
-    def set_layout_engine(self, layout=None, **kwargs):
-        """
-        Set the layout engine for this figure.
-
-        Parameters
-        ----------
-        layout: {'constrained', 'compressed', 'tight', 'none'} or \
-`LayoutEngine` or None
-
-            - 'constrained' will use `~.ConstrainedLayoutEngine`
-            - 'compressed' will also use `~.ConstrainedLayoutEngine`, but with
-              a correction that attempts to make a good layout for fixed-aspect
-              ratio Axes.
-            - 'tight' uses `~.TightLayoutEngine`
-            - 'none' removes layout engine.
-
-            If `None`, the behavior is controlled by :rc:`figure.autolayout`
-            (which if `True` behaves as if 'tight' was passed) and
-            :rc:`figure.constrained_layout.use` (which if `True` behaves as if
-            'constrained' was passed).  If both are `True`,
-            :rc:`figure.autolayout` takes priority.
-
-            Users and libraries can define their own layout engines and pass
-            the instance directly as well.
-
-        kwargs: dict
-            The keyword arguments are passed to the layout engine to set things
-            like padding and margin sizes.  Only used if *layout* is a string.
-
-        """
-        if layout is None:
-            if mpl.rcParams['figure.autolayout']:
-                layout = 'tight'
-            elif mpl.rcParams['figure.constrained_layout.use']:
-                layout = 'constrained'
-            else:
-                self._layout_engine = None
-                return
-        if layout == 'tight':
-            new_layout_engine = TightLayoutEngine(**kwargs)
-        elif layout == 'constrained':
-            new_layout_engine = ConstrainedLayoutEngine(**kwargs)
-        elif layout == 'compressed':
-            new_layout_engine = ConstrainedLayoutEngine(compress=True,
-                                                        **kwargs)
-        elif layout == 'none':
-            if self._layout_engine is not None:
-                new_layout_engine = PlaceHolderLayoutEngine(
-                    self._layout_engine.adjust_compatible,
-                    self._layout_engine.colorbar_gridspec
-                )
-            else:
-                new_layout_engine = None
-        elif isinstance(layout, LayoutEngine):
-            new_layout_engine = layout
-        else:
-            raise ValueError(f"Invalid value for 'layout': {layout!r}")
-
-        if self._check_layout_engines_compat(self._layout_engine,
-                                             new_layout_engine):
-            self._layout_engine = new_layout_engine
-        else:
-            raise RuntimeError('Colorbar layout of new layout engine not '
-                               'compatible with old engine, and a colorbar '
-                               'has been created.  Engine not changed.')
-
-    def get_layout_engine(self):
-        return self._layout_engine
-
-    # TODO: I'd like to dynamically add the _repr_html_ method
-    # to the figure in the right context, but then IPython doesn't
-    # use it, for some reason.
-
-    def _repr_html_(self):
-        # We can't use "isinstance" here, because then we'd end up importing
-        # webagg unconditionally.
-        if 'WebAgg' in type(self.canvas).__name__:
-            from matplotlib.backends import backend_webagg
-            return backend_webagg.ipython_inline_display(self)
-
-    def show(self, warn=True):
-        """
-        If using a GUI backend with pyplot, display the figure window.
-
-        If the figure was not created using `~.pyplot.figure`, it will lack
-        a `~.backend_bases.FigureManagerBase`, and this method will raise an
-        AttributeError.
-
-        .. warning::
-
-            This does not manage an GUI event loop. Consequently, the figure
-            may only be shown briefly or not shown at all if you or your
-            environment are not managing an event loop.
-
-            Use cases for `.Figure.show` include running this from a GUI
-            application (where there is persistently an event loop running) or
-            from a shell, like IPython, that install an input hook to allow the
-            interactive shell to accept input while the figure is also being
-            shown and interactive.  Some, but not all, GUI toolkits will
-            register an input hook on import.  See :ref:`cp_integration` for
-            more details.
-
-            If you're in a shell without input hook integration or executing a
-            python script, you should use `matplotlib.pyplot.show` with
-            ``block=True`` instead, which takes care of starting and running
-            the event loop for you.
-
-        Parameters
-        ----------
-        warn : bool, default: True
-            If ``True`` and we are not running headless (i.e. on Linux with an
-            unset DISPLAY), issue warning when called on a non-GUI backend.
-
-        """
-        if self.canvas.manager is None:
-            raise AttributeError(
-                "Figure.show works only for figures managed by pyplot, "
-                "normally created by pyplot.figure()")
-        try:
-            self.canvas.manager.show()
-        except NonGuiException as exc:
-            if warn:
-                _api.warn_external(str(exc))
-
-    @property
-    def axes(self):
-        """
-        List of Axes in the Figure. You can access and modify the Axes in the
-        Figure through this list.
-
-        Do not modify the list itself. Instead, use `~Figure.add_axes`,
-        `~.Figure.add_subplot` or `~.Figure.delaxes` to add or remove an Axes.
-
-        Note: The `.Figure.axes` property and `~.Figure.get_axes` method are
-        equivalent.
-        """
-        return self._axstack.as_list()
-
-    get_axes = axes.fget
-
     def _get_renderer(self):
         if hasattr(self.canvas, 'get_renderer'):
             return self.canvas.get_renderer()
@@ -3386,7 +3014,7 @@ None}, default: None
                mouse_pop=MouseButton.RIGHT,
                mouse_stop=MouseButton.MIDDLE):
         """
-        Blocking call to interact with a figure.
+        Blocking call to interact with the figure.
 
         Wait until the user clicks *n* times on the figure, and return the
         coordinates of each click in a list.
